Python un Redis integrācija: kešatmiņa un ziņojumu rinda

Redis ir atmiņā esoša datu struktūru krātuve, ko bieži izmanto kā datu bāzi, kešatmiņu un ziņojumu starpnieku. Tā ātrums un daudzpusība padara to par populāru izvēli Python izstrādātājiem, kuri vēlas uzlabot lietojumprogrammu veiktspēju un mērogojamību. Šis visaptverošais ceļvedis pēta, kā integrēt Redis ar Python gan kešatmiņai, gan ziņojumu rindošanai, sniedzot praktiskus piemērus un labāko praksi globālai auditorijai.

Kāpēc izmantot Redis ar Python?

Redis piedāvā vairākas priekšrocības, ja tas ir integrēts ar Python lietojumprogrammām:

• Ātrums: Redis glabā datus atmiņā, nodrošinot ārkārtīgi ātras lasīšanas un rakstīšanas operācijas. Tas ir ļoti svarīgi kešatmiņai un reāllaika datu apstrādei.
• Datu struktūras: Papildus vienkāršiem atslēgu-vērtību pāriem, Redis atbalsta sarežģītas datu struktūras, piemēram, sarakstus, kopas, sakārtotas kopas un jaucējtabulas, padarot to piemērotu dažādiem lietošanas gadījumiem.
• Pub/Sub: Redis nodrošina publicēšanas/abonēšanas mehānismu reāllaika saziņai starp dažādām lietojumprogrammas daļām vai pat starp dažādām lietojumprogrammām.
• Noturība: Lai gan Redis galvenokārt ir atmiņas krātuve, tas piedāvā noturības iespējas, lai nodrošinātu datu ilgmūžību servera kļūmju gadījumā.
• Mērogojamība: Redis var mērogot horizontāli, izmantojot tādas metodes kā sadalīšana, lai apstrādātu lielu datu un trafika apjomu.

Redis un Python vides iestatīšana

Redis instalēšana

Instalēšanas process atšķiras atkarībā no jūsu operētājsistēmas. Šeit ir instrukcijas dažām populārām platformām:

• Linux (Debian/Ubuntu): sudo apt update && sudo apt install redis-server
• macOS (izmantojot Homebrew): brew install redis
• Windows (izmantojot WSL vai Docker): Skatiet oficiālo Redis dokumentāciju, lai iegūtu Windows specifiskas instrukcijas. Docker ir izplatīta un ieteicama pieeja.

Pēc instalēšanas palaidiet Redis serveri. Lielākajā daļā sistēmu varat izmantot komandu redis-server.

Redis Python klienta instalēšana

Populārākais Python klients Redis ir redis-py. Instalējiet to, izmantojot pip:

pip install redis

Kešatmiņa ar Redis

Kešatmiņa ir fundamentāla metode lietojumprogrammu veiktspējas uzlabošanai. Glabājot bieži piekļūstamos datus Redis, jūs varat samazināt slodzi uz savu datu bāzi un ievērojami paātrināt atbildes laiku.

Pamata kešatmiņas piemērs

Šeit ir vienkāršs piemērs datu kešošanai, kas iegūti no datu bāzes, izmantojot Redis:

            \nimport redis\nimport time\n\n# Connect to Redis\nr = redis.Redis(host='localhost', port=6379, db=0)\n\n# Simulate a database query\ndef get_data_from_database(key):\n print(f"Fetching data from database for key: {key}")\n time.sleep(1) # Simulate a slow database query\n return f"Data for {key} from the database"\n\n# Function to get data from cache or database\ndef get_data(key):\n cached_data = r.get(key)\n if cached_data:\n print(f"Fetching data from cache for key: {key}")\n return cached_data.decode('utf-8')\n else:\n data = get_data_from_database(key)\n r.set(key, data, ex=60) # Cache for 60 seconds\n return data\n\n# Example usage\nprint(get_data('user:123'))\nprint(get_data('user:123')) # Fetches from cache\n
            

              
                Copy
              
            
          

Šajā piemērā:

• Mēs izveidojam savienojumu ar Redis instanci, kas darbojas uz localhost porta 6379.
• Funkcija get_data vispirms pārbauda, vai dati jau atrodas Redis kešatmiņā, izmantojot r.get(key).
• Ja dati atrodas kešatmiņā, tie tiek atgriezti tieši.
• Ja dati neatrodas kešatmiņā, tie tiek iegūti no datu bāzes, izmantojot get_data_from_database, saglabāti Redis ar derīguma termiņu (ex=60 sekundes) un pēc tam atgriezti.

Uzlabotas kešatmiņas tehnikas

• Kešatmiņas anulēšana: Pārliecinieties, ka jūsu kešatmiņas dati ir atjaunināti, anulējot kešatmiņu, ja pamatā esošie dati mainās. To var izdarīt, dzēšot kešatmiņā esošo atslēgu, izmantojot r.delete(key).
• Kešatmiņas-malā modelis: Iepriekš minētais piemērs demonstrē kešatmiņas-malā modeli, kurā lietojumprogramma ir atbildīga gan par lasīšanu no kešatmiņas, gan par tās atjaunināšanu, ja nepieciešams.
• Rakstīšanas-caur/Rakstīšanas-atpakaļ kešatmiņa: Šīs ir sarežģītākas kešatmiņas stratēģijas, kurās dati tiek rakstīti gan kešatmiņā, gan datu bāzē vienlaicīgi (rakstīšana-caur) vai vispirms tiek rakstīti kešatmiņā un pēc tam asinhroni ierakstīti datu bāzē (rakstīšana-atpakaļ).
• Dzīves laika (TTL) izmantošana: Pareiza TTL iestatīšana kešatmiņā esošajiem datiem ir ļoti svarīga, lai izvairītos no novecojušu datu pasniegšanas. Eksperimentējiet, lai atrastu optimālo TTL savām lietojumprogrammas vajadzībām.

Praktiski kešatmiņas scenāriji

• API atbilžu kešatmiņa: Kešojiet API galapunktu atbildes, lai samazinātu slodzi uz jūsu aizmugursistēmas serveriem.
• Datu bāzes vaicājumu kešatmiņa: Kešojiet bieži izpildītu datu bāzes vaicājumu rezultātus, lai uzlabotu atbildes laiku.
• HTML fragmentu kešatmiņa: Kešojiet HTML lapu fragmentus, lai samazinātu nepieciešamo servera puses atveidojuma apjomu.
• Lietotāja sesijas kešatmiņa: Glabājiet lietotāja sesijas datus Redis, lai nodrošinātu ātru piekļuvi un mērogojamību.

Ziņojumu rindošana ar Redis

Redis var izmantot kā ziņojumu starpnieku, lai ieviestu asinhronu uzdevumu apstrādi un atsaistīšanu starp dažādām jūsu lietojumprogrammas komponentēm. Tas ir īpaši noderīgi ilgstošu uzdevumu apstrādei, piemēram, attēlu apstrādei, e-pasta sūtīšanai vai atskaišu ģenerēšanai, nebloķējot galveno lietojumprogrammas pavedienu.

Redis Pub/Sub

Redis iebūvētais publicēšanas/abonēšanas (pub/sub) mehānisms ļauj jums nosūtīt ziņojumus vairākiem abonentiem. Tas ir vienkāršs veids, kā ieviest pamata ziņojumu rindošanu.

            \nimport redis\nimport time\nimport threading\n\n# Connect to Redis\nr = redis.Redis(host='localhost', port=6379, db=0)\n\n# Subscriber\ndef subscriber():\n pubsub = r.pubsub()\n pubsub.subscribe('my_channel')\n for message in pubsub.listen():\n if message['type'] == 'message':\n print(f\"Received message: {message['data'].decode('utf-8')}\")\n\n# Publisher\ndef publisher():\n time.sleep(1) # Wait for subscriber to connect\n for i in range(5):\n message = f\"Message {i}\"\n r.publish('my_channel', message)\n print(f\"Published message: {message}\")\n time.sleep(1)\n\n# Start subscriber in a separate thread\nsubscriber_thread = threading.Thread(target=subscriber)\nsubscriber_thread.start()\n\n# Start publisher in the main thread\npublisher()\n\nsubscriber_thread.join()\n
            

              
                Copy
              
            
          

Šajā piemērā:

• Funkcija subscriber abonē kanālu my_channel, izmantojot pubsub.subscribe('my_channel').
• Pēc tam tā klausās ziņojumus, izmantojot pubsub.listen(), un izdrukā visus saņemtos ziņojumus.
• Funkcija publisher publicē ziņojumus kanālā my_channel, izmantojot r.publish('my_channel', message).
• Abonents darbojas atsevišķā pavedienā, lai nebloķētu publicētāju.

Celery izmantošana

Celery ir populāra izplatīta uzdevumu rinda, kas var izmantot Redis kā ziņojumu starpnieku. Tā nodrošina robustāku un funkcijām bagātāku risinājumu ziņojumu rindošanai, salīdzinot ar Redis iebūvēto pub/sub.

Celery instalēšana

pip install celery redis

Celery konfigurācija

Izveidojiet failu celeryconfig.py ar šādu saturu:

            \nbroker_url = 'redis://localhost:6379/0'\nresult_backend = 'redis://localhost:6379/0'\n
            

              
                Copy
              
            
          

Uzdevumu definēšana

Izveidojiet failu tasks.py ar šādu saturu:

            \nfrom celery import Celery\nimport time\n\napp = Celery('tasks', broker='redis://localhost:6379/0', backend='redis://localhost:6379/0')\n\n@app.task\ndef add(x, y):\n time.sleep(5) # Simulate a long-running task\n return x + y\n
            

              
                Copy
              
            
          

Celery darbinieka palaišana

Atveriet termināli un palaidiet šādu komandu:

celery -A tasks worker --loglevel=info

Uzdevumu izsaukšana

            \nfrom tasks import add\n\nresult = add.delay(4, 4)\nprint(f"Task ID: {result.id}")\n\n# Later, you can check the result\n# print(result.get()) # This will block until the task is complete\n
            

              
                Copy
              
            
          

Šajā piemērā:

• Mēs definējam Celery uzdevumu ar nosaukumu add, kas pieņem divus argumentus un atgriež to summu.
• Funkcija add.delay(4, 4) nosūta uzdevumu Celery darbiniekam asinhronai izpildei.
• Objekts result attēlo asinhronā uzdevuma rezultātu. Varat izmantot result.get(), lai iegūtu rezultātu, kad uzdevums ir pabeigts. Ņemiet vērā, ka result.get() ir bloķējošs un gaidīs, kamēr uzdevums tiks pabeigts.

RQ (Redis Queue) izmantošana

RQ (Redis Queue) ir vēl viena populāra bibliotēka uzdevumu rindu ieviešanai ar Redis. Tā ir vienkāršāka par Celery, bet joprojām nodrošina stabilu risinājumu asinhronai uzdevumu apstrādei.

RQ instalēšana

pip install rq redis

Uzdevumu definēšana

Izveidojiet failu worker.py ar šādu saturu:

            \nimport redis\nfrom rq import Worker, Queue, Connection\nimport os\n\nlisten = ['default']\n\nredis_url = os.getenv('REDIS_URL', 'redis://localhost:6379')\n\nconn = redis.from_url(redis_url)\n\nif __name__ == '__main__':\n with Connection(conn):\n worker = Worker(list(map(Queue, listen)))\n worker.work()\n
            

              
                Copy
              
            
          

Izveidojiet failu tasks.py ar šādu saturu:

            \nimport time\n\ndef count_words_at_url(url):\n import requests\n resp = requests.get(url)\n return len(resp.text.split())\n
            

              
                Copy
              
            
          

Uzdevumu rindošana

            \nimport redis\nfrom rq import Queue\nfrom tasks import count_words_at_url\n\nredis_url = os.getenv('REDIS_URL', 'redis://localhost:6379')\nconn = redis.from_url(redis_url)\n\nq = Queue(connection=conn)\nresult = q.enqueue(count_words_at_url, 'http://nvie.com')\n\n#You can retrieve the job result later\n# from rq import job\n#job = Job.fetch(result.id, connection=conn)\n#print(job.result)\n
            

              
                Copy
              
            
          

RQ darbinieka palaišana

Atveriet termināli un palaidiet šādu komandu:

python worker.py

Šajā piemērā:

• Mēs definējam funkciju count_words_at_url, kas saskaita vārdus norādītajā URL.
• Mēs ievietojam uzdevumu rindā, izmantojot q.enqueue(count_words_at_url, 'http://nvie.com'), kas pievieno uzdevumu Redis rindai.
• RQ darbinieks paņem uzdevumu un izpilda to asinhroni.

Pareizās ziņojumu rindas izvēle

Izvēle starp Redis pub/sub, Celery un RQ ir atkarīga no jūsu lietojumprogrammas prasībām:

• Redis Pub/Sub: Piemērots vienkāršiem, reāllaika ziņojumapmaiņas scenārijiem, kur ziņojumu piegāde nav kritiska.
• Celery: Laba izvēle sarežģītākām uzdevumu rindām ar tādām funkcijām kā uzdevumu plānošana, atkārtota izpilde un rezultātu izsekošana. Celery ir nobriedušāks un funkcijām bagātāks risinājums.
• RQ: Vienkāršāka alternatīva Celery, piemērota pamata uzdevumu rindošanas vajadzībām. Vieglāk iestatāma un konfigurējama.

Redis datu struktūras uzlabotiem lietošanas gadījumiem

Redis piedāvā dažādas datu struktūras, kuras var izmantot sarežģītu problēmu efektīvai risināšanai.

Saraksti

Redis saraksti ir sakārtotas virkņu kolekcijas. Tos var izmantot, lai ieviestu rindas, kaudzes un citas datu struktūras.

            \nimport redis\n\nr = redis.Redis(host='localhost', port=6379, db=0)\n\nr.lpush('my_list', 'item1')\nr.lpush('my_list', 'item2')\nr.rpush('my_list', 'item3')\n\nprint(r.lrange('my_list', 0, -1)) # Output: [b'item2', b'item1', b'item3']\n
            

              
                Copy
              
            
          

Kopas

Redis kopas ir nesakārtotas unikālu virkņu kolekcijas. Tos var izmantot, lai ieviestu dalības testus, apvienošanas, šķēluma un atšķirību operācijas.

            \nimport redis\n\nr = redis.Redis(host='localhost', port=6379, db=0)\n\nr.sadd('my_set', 'item1')\nr.sadd('my_set', 'item2')\nr.sadd('my_set', 'item1') # Adding the same item again has no effect\n\nprint(r.smembers('my_set')) # Output: {b'item2', b'item1'}\n
            

              
                Copy
              
            
          

Sakārtotas kopas

Redis sakārtotās kopas ir līdzīgas kopām, taču katrs elements ir saistīts ar punktu skaitu. Elementi tiek sakārtoti, pamatojoties uz to punktu skaitu. Tos var izmantot, lai ieviestu līderu sarakstus, prioritāšu rindas un diapazona vaicājumus.

            \nimport redis\n\nr = redis.Redis(host='localhost', port=6379, db=0)\n\nr.zadd('my_sorted_set', {'item1': 10, 'item2': 5, 'item3': 15})\n\nprint(r.zrange('my_sorted_set', 0, -1)) # Output: [b'item2', b'item1', b'item3']\n
            

              
                Copy
              
            
          

Jaucējtabulas

Redis jaucējtabulas ir atslēgu-vērtību krātuves, kurās gan atslēga, gan vērtība ir virknes. Tos var izmantot objektu glabāšanai un atomu operāciju veikšanai ar atsevišķiem laukiem.

            \nimport redis\n\nr = redis.Redis(host='localhost', port=6379, db=0)\n\nr.hset('my_hash', 'field1', 'value1')\nr.hset('my_hash', 'field2', 'value2')\n\nprint(r.hgetall('my_hash')) # Output: {b'field1': b'value1', b'field2': b'value2'}\n
            

              
                Copy
              
            
          

Labākā prakse Python un Redis integrācijai

• Savienojumu apvienošana (Connection Pooling): Izmantojiet savienojumu apvienošanu, lai izvairītos no jauna savienojuma izveides ar Redis katrai operācijai. redis-py klients nodrošina iebūvētu savienojumu apvienošanu.
• Kļūdu apstrāde: Ieviesiet pareizu kļūdu apstrādi, lai uztvertu izņēmumus un graciozi apstrādātu savienojuma kļūdas.
• Datu serializācija: Izvēlieties atbilstošu datu serializācijas formātu, piemēram, JSON vai pickle, lai Redis glabātu sarežģītus objektus. Apsveriet katra formāta veiktspējas un drošības aspektus.
• Atslēgu nosaukumu konvencijas: Izmantojiet konsekventas un aprakstošas atslēgu nosaukumu konvencijas, lai sakārtotu savus datus Redis. Piemēram, user:{user_id}:name.
• Uzraudzība un žurnālēšana: Uzraugiet Redis servera veiktspēju un reģistrējiet visas kļūdas vai brīdinājumus. Izmantojiet tādus rīkus kā RedisInsight, lai uzraudzītu resursu izmantošanu un identificētu iespējamās vājās vietas.
• Drošība: Aizsargājiet savu Redis serveri, iestatot stipru paroli, atspējojot nevajadzīgas komandas un konfigurējot tīkla piekļuves ierobežojumus. Ja iespējams, palaidiet Redis aizsargātā tīkla vidē.
• Izvēlieties pareizo Redis instanci: Apsveriet savas lietojumprogrammas slodzi un izvēlieties pareizo Redis instances lielumu. Redis instances pārslogošana var izraisīt veiktspējas pasliktināšanos un nestabilitāti.

Globāli apsvērumi

• Laika joslas: Kešojot datus, kas ietver laika zīmogus, ņemiet vērā laika joslas un glabājiet laika zīmogus konsekventā formātā (piemēram, UTC).
• Valūtas: Kešojot finanšu datus, rūpīgi apstrādājiet valūtas konvertācijas.
• Rakstzīmju kodēšana: Izmantojiet UTF-8 kodējumu visām virknēm, kas glabātas Redis, lai atbalstītu plašu valodu klāstu.
• Lokalizācija: Ja jūsu lietojumprogramma ir lokalizēta, kešojiet dažādas datu versijas katram lokalizācijas reģionam.

Secinājums

Redis integrēšana ar Python var ievērojami uzlabot jūsu lietojumprogrammu veiktspēju un mērogojamību. Izmantojot Redis kešatmiņai un ziņojumu rindošanai, jūs varat samazināt slodzi uz jūsu datu bāzi, apstrādāt ilgstošus uzdevumus asinhroni un veidot atsaucīgākas un robustākas sistēmas. Šis ceļvedis sniedzis visaptverošu pārskatu par to, kā izmantot Redis ar Python, aptverot pamata jēdzienus, uzlabotas metodes un labāko praksi globālai auditorijai. Atcerieties ņemt vērā savas lietojumprogrammas specifiskās prasības un izvēlēties atbilstošus rīkus un stratēģijas, lai maksimāli izmantotu Redis integrācijas priekšrocības.